/**
 *@file gfx.c
 *@brief Contém todas as funções gráficas
 *
 *@details Elas são responsáveis por criar efeitos de
 * animação e gerenciar e manter o sistema gráfico.
 *
 *@author Copyright 2009 Vinícius dos Santos Oliveira
 *\n
 * This program is Free Software, distributed under the
 * terms of the GNU General Public License, published by
 * the Free Software Foundation; version 3 or any later
 * version published by the Free Software Foundation, at
 * your choice.
 */

/**
 *@addtogroup gráfico
 *@{
 */

static SDL_Surface * tiles[17] = {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
static SDL_Surface * gato_gfx[2] = {NULL,NULL};
static SDL_Surface * cozinheiro_gfx[2] = {NULL,NULL};
static SDL_Surface * fundo = NULL;
static SDL_Surface * mapa_base = NULL;
static SDL_Surface * tela = NULL;
static Bool_t iniciado = FALSE;
static unsigned int anima_pos = 0;

extern SDL_Thread * gfx_thread;
extern Tile_t mapa[25][20];
extern struct Anima * gato;
extern struct Anima * cozinheiro;

Bool_t gfx_feche = FALSE;

/**
 *@brief Prepara o sistema gráfico para ser usado.
 *@details O sistema gráfico usa uma série de informações,
 * como imagens, arrays e ponteiros, que precisam ser
 * inicializados. Para funcionar, é necessário chamar a
 * função gfx_feche (uma vez).
 *
 */
void gfx_prepare(){
/**
 *@{
 */
	if(iniciado == TRUE){
		return;
	}
	SDL_WM_SetCaption("Eater Thief",NULL);
	SDL_WM_SetIcon(IMG_Load("./icone.png"),NULL);
#	ifdef DEBUG
		char * tmp = NULL;
#	endif
#	ifdef SAFE_MODE
		tela = SDL_SetVideoMode(800,640,32,SDL_SWSURFACE);
#	elif defined RELEASE
		tela = SDL_SetVideoMode(800,640,32,SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_ASYNCBLIT|SDL_FULLSCREEN);
#	else
		tela = SDL_SetVideoMode(800,640,32,SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_ASYNCBLIT);
#	endif
	if(tela == NULL){
#		ifdef DEBUG
			fprintf(stderr,"Falhou ao inicalizar tela usando memória da placa de vídeo.\n"
			               "Erro: %s.\nTentando modo software.\n",tmp=SDL_GetError());
			free(tmp);
#		endif
		tela = SDL_SetVideoMode(800,640,32,SDL_SWSURFACE);
		if(tela == NULL){
			fprintf(stderr,"Falhou ao inicializar vídeo no modo software\n"
			               "Erro: %s.",SDL_GetError());
			return;
		}
	}
	unsigned short int i = 0;
	for(i = 0;i < 17;++i){
		if(tiles[i] == NULL){
			switch(i){
				case 0:
					tiles[0] = IMG_Load("./gfx/0000.png");
					break;
				case 1:
					tiles[1] = IMG_Load("./gfx/0001.png");
					break;
				case 2:
					tiles[2] = IMG_Load("./gfx/0010.png");
					break;
				case 3:
					tiles[3] = IMG_Load("./gfx/0011.png");
					break;
				case 4:
					tiles[4] = IMG_Load("./gfx/0100.png");
					break;
				case 5:
					tiles[5] = IMG_Load("./gfx/0101.png");
					break;
				case 6:
					tiles[6] = IMG_Load("./gfx/0110.png");
					break;
				case 7:
					tiles[7] = IMG_Load("./gfx/0111.png");
					break;
				case 8:
					tiles[8] = IMG_Load("./gfx/1000.png");
					break;
				case 9:
					tiles[9] = IMG_Load("./gfx/1001.png");
					break;
				case 0xa:
					tiles[10] = IMG_Load("./gfx/1010.png");
					break;
				case 0xb:
					tiles[11] = IMG_Load("./gfx/1011.png");
					break;
				case 0xc:
					tiles[12] = IMG_Load("./gfx/1100.png");
					break;
				case 0xd:
					tiles[13] = IMG_Load("./gfx/1101.png");
					break;
				case 0xe:
					tiles[14] = IMG_Load("./gfx/1110.png");
					break;
				case 0xf:
					tiles[15] = IMG_Load("./gfx/1111.png");
					break;
				case 0x10:
					tiles[16] = IMG_Load("./gfx/peixe.png");
			}
		}
		if(tiles[i] == NULL){
#			ifdef DEBUG
				fprintf(stderr,"Falha ao abrir arquivo.\nErro: %s.\n",SDL_GetError());
#			endif
			exit(EXIT_FAILURE);
		}
	}
	gato_gfx[0] = IMG_Load("./gfx/gato_do_ic.png");
	if(gato_gfx[0] == NULL){
#		ifdef DEBUG
			fprintf(stderr,"Não foi possível carregar a imagem gato_do_ic.png\nErro: %s.",SDL_GetError());
#		endif
		exit(EXIT_FAILURE);
	}
	gato_gfx[1] = IMG_Load("./gfx/gato_do_ic2.png");
	if(gato_gfx[1] == NULL){
#		ifdef DEBUG
			fprintf(stderr,"Não foi possível carregar a imagem gato_do_ic2.png\nErro: %s.",SDL_GetError());
#		endif
		exit(EXIT_FAILURE);
	}
	cozinheiro_gfx[0] = IMG_Load("./gfx/cozinheiro.png");
	if(cozinheiro_gfx[0] == NULL){
#		ifdef DEBUG
			fprintf(stderr,"Não foi possível carregar a imagem cozinheiro.png\nErro: %s.",SDL_GetError());
#		endif
		exit(EXIT_FAILURE);
	}
	cozinheiro_gfx[1] = IMG_Load("./gfx/cozinheiro2.png");
	if(cozinheiro_gfx[1] == NULL){
#		ifdef DEBUG
			fprintf(stderr,"Não foi possível carregar a imagem cozinheiro2.png\nErro: %s.",SDL_GetError());
#		endif
		exit(EXIT_FAILURE);
	}
	fundo = IMG_Load("./gfx/fundo.png");
	if(fundo == NULL){
#		ifdef DEBUG
			fprintf(stderr,"Não foi possível carregar a imagem fundo.png.\nErro: %s.\n",SDL_GetError());
#		endif
		exit(EXIT_FAILURE);
	}
	mapa_base = IMG_Load("./gfx/fundo.png");
	if(mapa_base == NULL){
#		ifdef DEBUG
		fprintf(stderr,"Não foi possível carregar a imagem fundo.png.\nErro: %s.\n",SDL_GetError());
#		endif
		exit(EXIT_FAILURE);
	}
	iniciado = TRUE;
/**
 *@}
 */
}

/**
 *@brief A função gfx_sair desaloca todos os dados alocados
 * durante a inicialização.
 *@details Ela é chamada automaticamente quando o jogo fecha
 * graças a função atexit.
 */
void gfx_sair(){
/**
 *@{
 */
	if(gfx_thread != NULL){
		if(gfx_feche == FALSE){
			gfx_feche = TRUE;
			SDL_WaitThread(gfx_thread,NULL);
			gfx_thread = NULL;
		}
	}
	SDL_Delay(100);
	unsigned int i;
	for(i = 0;i < 17;++i){
		SDL_FreeSurface(tiles[i]);
		tiles[i] = NULL;
	}
	SDL_FreeSurface(gato_gfx[0]);
	SDL_FreeSurface(gato_gfx[1]);
	SDL_FreeSurface(cozinheiro_gfx[0]);
	SDL_FreeSurface(cozinheiro_gfx[1]);
	SDL_FreeSurface(fundo);
	fundo = NULL;
	SDL_FreeSurface(mapa_base);
	mapa_base = NULL;
	SDL_FreeSurface(tela);
	tela = NULL;
	iniciado = false;
/**
 *@}
 */
}

/**
 *@brief Função de ligação interna usada
 * como auxiliar as funções do sistema
 * gráfico.
 */
inline void por_tile(Tile_t tileid,unsigned int x,unsigned int y,Bool_t totela){
/**
 *@{
 */
	if(!tileid){
		return;
	}
	--tileid;
	SDL_Surface * destino = totela ? tela : mapa_base;
	SDL_Rect aux;
	aux.x = x;
	aux.y = y;
	aux.w = 32;
	aux.h = 32;
	if(tileid < 17){
		SDL_BlitSurface(tiles[tileid],NULL,destino,&aux);
	}else if(tileid == 17){
		SDL_BlitSurface(gato_gfx[anima_pos],NULL,destino,&aux);
	}else{
		SDL_BlitSurface(cozinheiro_gfx[anima_pos],NULL,destino,&aux);
	}
/**
 *@}
 */
}

/**
 *@brief Prepara o sistema gráfico para desenhar um novo mapa.
 *@details Essa função sempre deve ser chamada quando o mapa
 * for alterado, pois ela cria uma nova imagem do mapa. Ela é
 * necessária para diminuir o lag que era causado no sistema
 * gráfico antigo.
 */
void gfx_cartografo(){
/**
 *@{
 */
	SDL_BlitSurface(fundo,NULL,mapa_base,NULL);
	unsigned short int i,j;
	for(j = 0;j < 20;++j){
		for(i = 0;i < 25;++i){
			if((mapa[i][j] > 0)&&(mapa[i][j] < 17)){
				por_tile(mapa[i][j],i*32,j*32,FALSE);
			}
		}
	}
/**
 *@}
 */
}

/**
 *@brief Desenha e atualiza o jogo.
 *@details A função gfx_main é responsável por ficar
 * desenhando e atualizando a tela do jogo. \n
 * Deve ser iniciada com:
 *@code
 * gfx_thread = SDL_CreateThread(gfx_main,ponteiro);
 * @endcode
 * Onde ponteiro é o endereço de um unsigned int que
 * armazena a quantos frames por segundo o sistema
 * deve operar.
 *@param [in] gfx_fps Frames por segundo.
 *@return Retorna 0.
 *@warning Eu desabilitei o sistema dinâmico de
 * atualização, assim, não é mais possível mudar o
 * fps depois que a função é chamada, e antes de ser
 * terminada. \n
 * Eu não preparei o sistema para impedir que duas
 * instâncias dessa função sejam permitidas assim
 * como não coloquei nenhuma trava.
 */
int gfx_main(void * gfx_fps){
/**
 *@{
 */
	Uint32 tempo,tempo_aux;
	unsigned short int i,j;
	unsigned int delay = 1000/(*((unsigned int *)(gfx_fps)));
	struct Anima * atual = cozinheiro;
	while(!gfx_feche){
		tempo = SDL_GetTicks();
		SDL_BlitSurface(mapa_base,NULL,tela,NULL);
		for(j = 0;j < 20;++j){
			for(i = 0;i < 25;++i){
				if(mapa[i][j] == 17){
					por_tile(17,i*32,j*32,TRUE);
				}
			}
		}
		if(gato != NULL){
			por_tile(18,gato->x,gato->y,TRUE);
		}
		if(atual != NULL){
			while(atual->anterior != NULL){
				atual = atual->anterior;
			}
			while(atual->proximo != NULL){
				por_tile(19,atual->x,atual->y,TRUE);
				atual = atual->proximo;
			}
		}
		switch(anima_pos){
			case 0:
				anima_pos = 1;
				break;
			case 1:
				anima_pos = 0;
		}
		if((tempo_aux = SDL_GetTicks() - tempo) < delay){
			SDL_Delay(delay -tempo_aux);
		}
		SDL_Flip(tela);
	}
	gfx_feche = FALSE;
	return 0;
/**
 *@}
 */
}

/**
 *@brief Função que cria o efeito inicial de animação
 */
void intro(){
/**
 *@{
 */
	register short int i;
	Uint32 tempo;
	SDL_Surface *gfxf[21];
	gfxf[0] = IMG_Load("./gfx/fundopreto.png");
	gfxf[1] = IMG_Load("./gfx/intro2.png");
	gfxf[2] = IMG_Load("./gfx/intro3.png");
	gfxf[3] = IMG_Load("./gfx/intro4.png");
	gfxf[4] = IMG_Load("./gfx/intro5.png");
	gfxf[5] = IMG_Load("./gfx/intro6.png");
	gfxf[6] = IMG_Load("./gfx/intro7.png");
	gfxf[7] = IMG_Load("./gfx/intro8.png");
	gfxf[8] = IMG_Load("./gfx/intro9.png");
	gfxf[9] = IMG_Load("./gfx/intro10.png");
	gfxf[10] = IMG_Load("./gfx/intro11.png");
	gfxf[11] = IMG_Load("./gfx/intro12.png");
	gfxf[12] = IMG_Load("./gfx/intro13.png");
	gfxf[13] = IMG_Load("./gfx/intro14.png");
	gfxf[14] = IMG_Load("./gfx/intro15.png");
	gfxf[15] = IMG_Load("./gfx/intro16.png");
	gfxf[16] = IMG_Load("./gfx/intro17.png");
	gfxf[17] = IMG_Load("./gfx/intro18.png");
	gfxf[18] = IMG_Load("./gfx/intro19.png");
	gfxf[19] = IMG_Load("./gfx/intro20.png");
	gfxf[20] = IMG_Load("./gfx/intro.png");
	for(i=0;i<21;++i){
		if(gfxf[i]==NULL){
#			ifdef DEBUG
				fprintf(stderr,"Não foi possível carregar intr*png.\nErro: %s.\n",SDL_GetError());
#			endif
			exit(EXIT_FAILURE);
		}
	}
	for(i=0;i<20;++i){
		tempo = SDL_GetTicks();
		SDL_BlitSurface(gfxf[i],NULL,tela,NULL);
		SDL_Flip(tela);
		SDL_Delay(100 + tempo - SDL_GetTicks());
		tempo = SDL_GetTicks();
	}
	SDL_BlitSurface(gfxf[20],NULL,tela,NULL);
	SDL_Flip(tela);
	SDL_Delay(500 + tempo - SDL_GetTicks());
	for(i=19;i>=0;--i){
		SDL_BlitSurface(gfxf[i],NULL,tela,NULL);
		SDL_Flip(tela);
		SDL_Delay(50);
	}
	SDL_Delay(50);
	for(i=0;i<21;++i){
		SDL_FreeSurface(gfxf[i]);
	}
	return;
/**
 *@}
 */
}

/**
 *@param opcao_nts em que opção no menu a animação
 * deve começar
 *@param opcao_dps em que opção deve terminar
 *@brief função que cria o efeito de animação para
 * o menu.
 */
void draw_menu(short int opcao_nts,short int opcao_dps){
/**
 *@{
 */
	--opcao_nts;
	--opcao_dps;
	if((opcao_nts<0)||(opcao_nts>2)||(opcao_dps<0)||(opcao_dps>2)||(tela==NULL)){
#		ifdef DEBUG
			fprintf(stderr,"opção inválida\n");
#		endif
		return;
	}
	register int j,k;
	int prox;
	SDL_Surface * fundo=NULL,* const cursor=IMG_Load("./gfx/cursor.png");
	SDL_Rect pos[3],aux;
	pos[0].w = pos[0].h = pos[1].w = pos[1].h = pos[2].w = pos[2].h = aux.w = aux.h = 0;
	pos[0].x = 295;
	pos[0].y = 281;
	pos[1].x = 265;
	pos[1].y = 390;
	pos[2].x = 334;
	pos[2].y = 507;
	if(cursor == NULL){
#		ifdef DEBUG
			fprintf(stderr,"Não foi possível carregar a imagem cursor.png.\nErro: %s.\n",SDL_GetError());
#		endif
		exit(EXIT_FAILURE);
	}
	switch(opcao_nts){
		case 0:
			fundo = IMG_Load("./gfx/menu_1.png");
			if(fundo == NULL){
#				ifdef DEBUG
					fprintf(stderr,"Não foi possível carregar a imagem menu_1.png.\nErro: %s.\n",SDL_GetError());
#				endif
				exit(EXIT_FAILURE);
			}
			break;
		case 1:
			fundo = IMG_Load("./gfx/menu_2.png");
			if(fundo == NULL){
#				ifdef DEBUG
					fprintf(stderr,"Não foi possível carregar a imagem menu_2.png.\nErro: %s.\n",SDL_GetError());
#				endif
				exit(EXIT_FAILURE);
			}
			break;
		case 2:
			fundo = IMG_Load("./gfx/menu_3.png");
			if(fundo == NULL){
#				ifdef DEBUG
					fprintf(stderr,"Não foi possível carregar a imagem menu_3.png.\nErro: %s.\n",SDL_GetError());
#				endif
				exit(EXIT_FAILURE);
			}
			break;
	}
	if(opcao_nts==opcao_dps){
		SDL_BlitSurface(fundo,NULL,tela,NULL);
		switch(opcao_nts){
			case 0:
				SDL_BlitSurface(cursor,NULL,tela,pos);
				SDL_FreeSurface(fundo);
				SDL_FreeSurface(cursor);
				SDL_Flip(tela);
				SDL_Delay(100);
				return;
			case 1:
				SDL_BlitSurface(cursor,NULL,tela,&pos[1]);
				SDL_FreeSurface(fundo);
				SDL_FreeSurface(cursor);
				SDL_Flip(tela);
				SDL_Delay(100);
				return;
			case 2:
				SDL_BlitSurface(cursor,NULL,tela,&pos[2]);
				SDL_FreeSurface(fundo);
				SDL_FreeSurface(cursor);
				SDL_Flip(tela);
				SDL_Delay(100);
				return;
		}
	}else{
#		ifdef SAFE_MODE
			switch(opcao_nts){
				case 0:
					fundo = IMG_Load("./gfx/menu_1.png");
					if(fundo == NULL){
#						ifdef DEBUG
							fprintf(stderr,"Não foi possível carregar a imagem menu_1.png.\nErro: %s.\n",SDL_GetError());
#						endif
						exit(EXIT_FAILURE);
					}
					SDL_BlitSurface(fundo,NULL,tela,NULL);
					SDL_BlitSurface(cursor,NULL,tela,pos);
					SDL_FreeSurface(fundo);
					SDL_Flip(tela);
					SDL_Delay(100);
					return;
				case 1:
					fundo = IMG_Load("./gfx/menu_2.png");
					if(fundo == NULL){
#						ifdef DEBUG
							fprintf(stderr,"Não foi possível carregar a imagem menu_2.png.\nErro: %s.\n",SDL_GetError());
#						endif
						exit(EXIT_FAILURE);
					}
					SDL_BlitSurface(fundo,NULL,tela,NULL);
					SDL_BlitSurface(cursor,NULL,tela,&pos[1]);
					SDL_FreeSurface(fundo);
					SDL_Flip(tela);
					SDL_Delay(100);
					return;
				case 2:
					fundo = IMG_Load("./gfx/menu_3.png");
					if(fundo == NULL){
#						ifdef DEBUG
							fprintf(stderr,"Não foi possível carregar a imagem menu_3.png.\nErro: %s.\n",SDL_GetError());
#						endif
						exit(EXIT_FAILURE);
					}
					SDL_BlitSurface(fundo,NULL,tela,NULL);
					SDL_BlitSurface(cursor,NULL,tela,&pos[2]);
					SDL_FreeSurface(fundo);
					SDL_Flip(tela);
					SDL_Delay(100);
					return;
			}
			switch(opcao_dps){
				case 0:
					fundo = IMG_Load("./gfx/menu_1.png");
					if(fundo == NULL){
#						ifdef DEBUG
							fprintf(stderr,"Não foi possível carregar a imagem menu_1.png.\nErro: %s.\n",SDL_GetError());
#						endif
						exit(EXIT_FAILURE);
					}
					SDL_BlitSurface(fundo,NULL,tela,NULL);
					SDL_BlitSurface(cursor,NULL,tela,pos);
					SDL_FreeSurface(fundo);
					SDL_FreeSurface(cursor);
					SDL_Flip(tela);
					SDL_Delay(150);
					break;
				case 1:
					fundo = IMG_Load("./gfx/menu_2.png");
					if(fundo == NULL){
#						ifdef DEBUG
							fprintf(stderr,"Não foi possível carregar a imagem menu_1.png.\nErro: %s.\n",SDL_GetError());
#						endif
						exit(EXIT_FAILURE);
					}
					SDL_BlitSurface(fundo,NULL,tela,NULL);
					SDL_BlitSurface(cursor,NULL,tela,&pos[1]);
					SDL_FreeSurface(fundo);
					SDL_FreeSurface(cursor);
					SDL_Flip(tela);
					SDL_Delay(150);
					break;
				case 2:
					fundo = IMG_Load("./gfx/menu_3.png");
					if(fundo == NULL){
#						ifdef DEBUG
							fprintf(stderr,"Não foi possível carregar a imagem menu_1.png.\nErro: %s.\n",SDL_GetError());
#						endif
						exit(EXIT_FAILURE);
					}
					SDL_BlitSurface(fundo,NULL,tela,NULL);
					SDL_BlitSurface(cursor,NULL,tela,&pos[2]);
					SDL_FreeSurface(fundo);
					SDL_FreeSurface(cursor);
					SDL_Flip(tela);
					SDL_Delay(150);
					break;
			}
#		else
			float proporcao;
			if(opcao_nts<opcao_dps){
				prox = opcao_nts+1;
			}else{
				prox = opcao_nts-1;
			}
			SDL_BlitSurface(fundo,NULL,tela,NULL);
			SDL_BlitSurface(cursor,NULL,tela,&pos[opcao_nts]);
			SDL_Flip(tela);
			SDL_Delay(1);
			aux.x = pos[opcao_nts].x;
			for(j=pos[opcao_nts].y;j!=pos[opcao_dps].y;j<pos[opcao_dps].y?++j:--j){
				SDL_BlitSurface(fundo,NULL,tela,NULL);
				proporcao = j-pos[opcao_nts].y;
				proporcao /= pos[prox].y-pos[opcao_nts].y;
				if(pos[opcao_nts].x<pos[prox].x){
					aux.x = pos[opcao_nts].x + (int)((pos[prox].x-pos[opcao_nts].x)*proporcao);
				}else{
					aux.x = pos[opcao_nts].x - (int)((pos[opcao_nts].x-pos[prox].x)*proporcao);
				}
				aux.y = j;
				SDL_BlitSurface(cursor,NULL,tela,&aux);
				SDL_Flip(tela);
				SDL_Delay(1);
				k = opcao_nts<opcao_dps?1:0;
				if(k){
					if(j==pos[prox].y){
						++opcao_nts;
						++prox;
					}
				}else{
					if(j==pos[prox].y){
						--opcao_nts;
						--prox;
					}
				}
			}
			SDL_FreeSurface(fundo);
			switch(opcao_dps){
				case 0:
					fundo = IMG_Load("./gfx/menu_1.png");
					if(fundo == NULL){
#						ifdef DEBUG
							fprintf(stderr,"Não foi possível carregar a imagem menu_1.png.\nErro: %s.\n",SDL_GetError());
#						endif
						exit(EXIT_FAILURE);
					}
					break;
				case 1:
					fundo = IMG_Load("./gfx/menu_2.png");
					if(fundo == NULL){
#						ifdef DEBUG
							fprintf(stderr,"Não foi possível carregar a imagem menu_1.png.\nErro: %s.\n",SDL_GetError());
#						endif
						exit(EXIT_FAILURE);
					}
					break;
				case 2:
					fundo = IMG_Load("./gfx/menu_3.png");
					if(fundo == NULL){
#						ifdef DEBUG
							fprintf(stderr,"Não foi possível carregar a imagem menu_1.png.\nErro: %s.\n",SDL_GetError());
#						endif
						exit(EXIT_FAILURE);
					}
					break;
			}
			SDL_BlitSurface(fundo,NULL,tela,NULL);
			SDL_BlitSurface(cursor,NULL,tela,&pos[opcao_dps]);
			SDL_Flip(tela);
			SDL_Delay(50);
			SDL_FreeSurface(fundo);
			SDL_FreeSurface(cursor);
#		endif
		return;
	}
/**
 *@}
 */
}

/**
 *@brief Exibe a animaçã de gameover.
 */
void gameover(){
/**
 *@{
 */
	unsigned short int i;
	SDL_Surface * fundo,* imagem;
	Uint32 inicio = SDL_GetTicks();
	fundo = IMG_Load("./gfx/fundobranco.png");
	if(fundo == NULL){
#		ifdef DEBUG
			fprintf(stderr,"Não foi possível carregar a imagem fundobranco.png\nErro: %s.\n",SDL_GetError());
#		endif
		exit(EXIT_FAILURE);
	}
	imagem = IMG_Load("./gfx/gameover1.png");
	if(imagem == NULL){
#		ifdef DEBUG
			fprintf(stderr,"Não foi possível carregar a imagem gameover1.png.\nErro: %s.\n",SDL_GetError());
#		endif
		exit(EXIT_FAILURE);
	}
	SDL_BlitSurface(fundo,NULL,tela,NULL);
	for(i=0;i<4;++i){
		SDL_BlitSurface(imagem,NULL,tela,NULL);
		SDL_Delay(100 + inicio - SDL_GetTicks());
		inicio = SDL_GetTicks();
	}
	SDL_FreeSurface(imagem);
	imagem = IMG_Load("./gfx/gameover.png");
	if(imagem == NULL){
#		ifdef DEBUG
			fprintf(stderr,"Não foi possível carregar a imagem gameover.png.\nErro: %s.\n",SDL_GetError());
#		endif
		exit(EXIT_FAILURE);
	}
	SDL_BlitSurface(imagem,NULL,tela,NULL);
	SDL_Delay(150);
	SDL_FreeSurface(fundo);
	SDL_FreeSurface(imagem);
	return;
/**
 *@}
 */
}

/**
 *@brief Mostra os gráficos
 */
int creditos(void * durante){
/**
 *@{
 */
	return;//a função créditos faço esse final de semana
/**
 *@}
 */
}


/**
 *@}
 */
